package com.zy.orders.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.zy.model.Cart;
import com.zy.orders.mapper.CartMapper;
import com.zy.web.api.IdGeneratorApi;
import com.zy.web.api.ProductApi;
import com.zy.web.bean.CartDTO;
import com.zy.web.bean.ProductDTO;
import com.zy.web.bean.ResponseResult;
import lombok.AllArgsConstructor;
import lombok.extern.java.Log;
import org.springframework.beans.BeanUtils;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.stream.Collectors;

@Service
@Log
@AllArgsConstructor
public class CartServiceImpl extends ServiceImpl<CartMapper, Cart> implements CartService {
    private final IdGeneratorApi idGeneratorApi;
    private final ProductApi productApi;

    private final ObjectMapper objectMapper;

    /**
     * 添加商品到购物车或更新商品数量
     * @param userId 用户ID
     * @param productInfo 商品的详细信息 DTO (由前端提供)
     * @param quantity 购买数量
     * @return 添加或更新后的购物车项DTO
     */
    @Override
    @Transactional
    public CartDTO addItemToCart(Long userId, ProductDTO productInfo, Integer quantity) {
        if (userId == null || productInfo == null || productInfo.getProductId() == null || quantity == null || quantity <= 0) {
            throw new IllegalArgumentException("用户ID、商品信息和数量不能为空，且数量必须大于0");
        }
        Long productId = productInfo.getProductId();
        // 1. 检查购物车中是否已存在该商品
        LambdaQueryWrapper<Cart> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Cart::getUserId, userId)
                .eq(Cart::getProductId, productId);
        // 使用 this.getOne() 替代 cartMapper.selectOne()
        Cart existingCart = this.getOne(queryWrapper);
        Cart cart = new Cart();
        boolean success; // 使用 boolean 标记操作结果
        if (existingCart != null) {
            // 2. 如果商品已存在，则更新数量
            cart = existingCart;
            cart.setQuantity(existingCart.getQuantity() + quantity); // 累加数量
            // 直接使用 this.updateById() 更简洁，前提是 Cart 实体有 @TableId
            // 或者使用 this.update(entity, updateWrapper)
            success = this.updateById(cart); // <--- 使用 ServiceImpl 提供的 updateById
            log.info("用户 " + userId + " 的购物车商品 " + productId + " 数量更新为 " + cart.getQuantity());
        } else {
            // 3. 如果商品不存在，则新增购物车项
            ResponseResult rr = this.idGeneratorApi.getNextId();
            if (rr.getCode() != 1) {
                throw new RuntimeException("购物车ID生成失败");
            }
            Long cartId = Long.parseLong(rr.getData().toString());
            cart.setCartId(cartId);
            cart.setUserId(userId);
            cart.setProductId(productId);
            cart.setQuantity(quantity);
            success = this.save(cart); // <--- 使用 ServiceImpl 提供的 save
            log.info("用户 " + userId + " 新增购物车商品 " + productId + "，数量 " + quantity);
        }
        if (success) {
            return convertToCartDTOWithProductInfo(cart, productInfo);
        } else {
            throw new RuntimeException("添加/更新购物车失败");
        }
    }

    /**
     * 更新购物车中商品的数量
     * @param userId 用户ID
     * @param cartId 购物车项ID
     * @param quantity 新的数量
     * @return 更新后的购物车项DTO，如果不存在则返回null
     */
    @Override
    @Transactional
    public CartDTO updateCartItemQuantity(Long userId, Long cartId, Integer quantity) {
        if (userId == null || cartId == null || quantity == null || quantity <= 0) {
            throw new IllegalArgumentException("用户ID、购物车项ID和数量不能为空，且数量必须大于0");
        }
        // 可以先查询确保存在且属于该用户，然后再更新
        Cart existingCart = this.getById(cartId); // <--- 使用 ServiceImpl 提供的 getById
        if (existingCart == null || !existingCart.getUserId().equals(userId)) {
            log.warning("用户 " + userId + " 尝试更新购物车项 " + cartId + " 数量失败，可能不存在或不属于该用户。");
            return null;
        }
        existingCart.setQuantity(quantity);
        boolean success = this.updateById(existingCart);
        if (success) {
            Cart updatedCart = this.getById(cartId);
            log.info("用户 " + userId + " 的购物车项 " + cartId + " 数量更新为 " + quantity);
            ResponseEntity<ResponseResult> rr = productApi.getProductById(updatedCart.getProductId());
            ResponseResult responseResult = (ResponseResult) rr.getBody();
            if( responseResult.getCode()==1){
                //   因为没有书写泛型 ，所以getData()得到的是一个LinkedHashMap, 必须要  转换成 ProductDTO.
                ProductDTO productDTO = objectMapper.convertValue(responseResult.getData(), ProductDTO.class);
                return convertToCartDTOWithProductInfo(updatedCart,productDTO);

            }
            return null;
        } else {
            log.warning("用户 " + userId + " 尝试更新购物车项 " + cartId + " 数量失败。");
            return null;
        }
    }

    /**
     * 从购物车中删除指定商品
     * @param userId 用户ID
     * @param cartId 购物车项ID
     * @return 是否删除成功
     */
    @Override
    @Transactional
    public boolean deleteCartItem(Long userId, Long cartId) {
        if (userId == null || cartId == null) {
            throw new IllegalArgumentException("用户ID和购物车项ID不能为空");
        }
        // 可以先查询确保存在且属于该用户，然后再删除
        Cart existingCart = this.getById(cartId); // <--- 使用 ServiceImpl 提供的 getById
        if (existingCart == null || !existingCart.getUserId().equals(userId)) {
            log.warning("用户 " + userId + " 尝试删除购物车项 " + cartId + " 失败，可能不存在或不属于该用户。");
            return false;
        }
        boolean success = this.removeById(cartId); // <--- 使用 ServiceImpl 提供的 removeById
        if (success) {
            log.info("用户 " + userId + " 删除了购物车项 " + cartId);
        } else {
            log.warning("用户 " + userId + " 尝试删除购物车项 " + cartId + " 失败。");
        }
        return success;
    }


    /**
     * 获取用户购物车中的所有商品列表
     * @param userId 用户ID
     * @return 购物车项DTO列表，包含商品详细信息
     */
    @Override
    public List<CartDTO> getCartItems(Long userId) {
        if (userId == null) {
            throw new IllegalArgumentException("用户ID不能为空");
        }
        LambdaQueryWrapper<Cart> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Cart::getUserId, userId);
        List<Cart> carts = this.list(queryWrapper);
        return carts.stream()
                .map(cart -> {
                    ResponseEntity<ResponseResult> rr = productApi.getProductById(cart.getProductId());
                    ResponseResult responseResult = (ResponseResult) rr.getBody();
                    if( responseResult.getCode()==1){
                       ProductDTO productDTO = objectMapper.convertValue(responseResult.getData(), ProductDTO.class);
                        return convertToCartDTOWithProductInfo(cart, productDTO);
                    }
                    return null;
                })
                .filter(dto -> dto != null)
                .collect(Collectors.toList());
    }

    /**
     * 清空用户购物车
     * @param userId 用户ID
     * @return 是否清空成功
     */
    @Override
    @Transactional
    public boolean clearCart(Long userId) {
        if (userId == null) {
            throw new IllegalArgumentException("用户ID不能为空");
        }

        LambdaQueryWrapper<Cart> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Cart::getUserId, userId);

        // 使用 this.remove() 替代 cartMapper.delete()
        boolean success = this.remove(queryWrapper); // <--- 使用 ServiceImpl 提供的 remove
        if (success) {
            log.info("用户 " + userId + " 清空了购物车");
        } else {
            log.info("用户 " + userId + " 的购物车已为空或清空失败。");
        }
        return success;
    }

    /**
     * 辅助方法：将 Cart 实体和 ProductDTO 转换为 CartDTO
     * @param cart Cart 实体
     * @param product ProductDTO
     * @return 包含商品信息的 CartDTO
     */
    private CartDTO convertToCartDTOWithProductInfo(Cart cart, ProductDTO product) {
        if (cart == null) {
            return null;
        }
        CartDTO cartDTO = new CartDTO();
        BeanUtils.copyProperties(cart, cartDTO);

        if (product != null) {
            cartDTO.setProductName(product.getProductName());
            cartDTO.setPrice(product.getPrice());
            cartDTO.setOriginalPrice(product.getOriginalPrice());
            cartDTO.setMainImage(product.getMainImage());
        } else {
            log.warning("购物车项中商品ID: " + cart.getProductId() + " 未找到对应商品信息，或传入的 productInfo 为空。");
            return null;
        }
        return cartDTO;
    }
}
